// The Vue build version to load with the `import` command
// (runtime-only or standalone) has been set in webpack.base.conf with an alias.
import Vue from 'vue'
import Vuex from 'vuex'
import FastClick from 'fastclick'
import 'less'
import 'lib-flexible'
import axios from 'axios'
import App from './App'
import store from './store/store'
import draggable from 'vuedraggable'
import { WechatPlugin, AlertPlugin, ToastPlugin, ConfirmPlugin, LoadingPlugin } from 'vux'
import api from './api'
import router from './router'
import utils from './utils'

Vue.use(WechatPlugin)
Vue.use(ConfirmPlugin)
Vue.use(AlertPlugin)
Vue.use(ToastPlugin)
Vue.use(LoadingPlugin)
Vue.use(Vuex)
FastClick.attach(document.body)
// 注册插件
Vue.prototype.axios = axios
Vue.config.productionTip = false
/* eslint-disable no-new */

// 在正式环境中隐藏所有log记录
if (process.env.NODE_ENV === 'production') {
  console.log = function () { }
}

var noncestring = utils.randomString(32)
var code = utils.getQueryString('code')
store.commit('changeIndexConf', {
  noncestr: noncestring
})

var timestamp = String(parseInt((Number(new Date())) / 1000))
var token = utils.AnonToken(timestamp)
// var sharelink = getQueryString('shareParam') // 获取链接分享不再授权的判断参数

// status
// -6: 邀请用户，需要授权和注册
// -5: token过期， 需要重新登录和授权
// -4: 微信失败，需要从新登录和授权
// -3: 用户登出，需要重新登录和授权
// -2: 联合登录用于不存在，需要注册和授权（可能是绑定openId失败，需要跳登录页面)
// -1: 用户注册失败，需要注册和授权
// 0: 已经注册, 初始状态
// 1: 已登录，不需要授权

var status = localStorage.getItem('status') // 获取当前状态
// var lastRouter = localStorage.getItem('lastRouter') // 当前应该跳转的路由
// var lastParams = localStorage.getItem('lastParams') // 应该带着的参数
if (code) {
  store.commit('changeIndexConf', {
    wxCode: code
  })
  status = localStorage.getItem('status')
  if (status === '-2') {
    initVue()
    router.push({
      path: '/passport/login',
      query: utils.toQueryParams(window.location.href)
    })
  } else if (status === '-6') { // 都是需要注册页面，需要调回注册页面
    initVue()
    router.push({
      path: '/passport/register',
      query: utils.toQueryParams(window.location.href)
    })
  } else if (status === '-3') {
    initVue()
    router.push({
      path: '/passport/login',
      query: utils.toQueryParams(window.location.href)
    })
  } else if (status === '-1') { // -1为注册失败，需要调回注册页面
    initVue()
    router.push({
      path: '/passport/register',
      query: utils.toQueryParams(window.location.herf)
    })
  } else if (status === '1') { // 避免用户回退死循环
    initVue()
  } else {
    tryLogin()
  }
} else {
  var path = window.location.href.split(process.env.BASE_URL)[1]
  localStorage.setItem('path', window.location.pathname)
  if (path) {
    localStorage.setItem('lastRouter', path.split('?')[0])
    localStorage.setItem('lastParams', path.split('?')[1])
  }
  if (urlFilter()) { // 分享链接，不需要授权
    initVue()
  } else {
    if (status === '1') { // 用户已经登录，直接打开页面
      initVue()
    } else {
      // 缓存授权前url
      utils.redirectWx(true) // 绝对缓存url
    }
  }
}
function urlFilter () {
  var ua = navigator.userAgent.toLowerCase()
  var isWeixin = ua.indexOf('micromessenger') !== -1
  var isShare = utils.getQueryString('shareParam')
  if (isShare === 'share') {
    return true
  } else if (isShare === 'invite' && isWeixin === true) {
    utils.redirectWx('-6')
    return false
  } else if (isWeixin === false) {
    window.location.href = '/load/index?shareParam=share'
    return true
  } else return false
}
function tryLogin () {
  localStorage.setItem('request', JSON.stringify({
    token: token,
    timestamp: timestamp,
    authCode: code,
    from: 0,
    loginType: 2
  }))
  api.login({
    token: token,
    timestamp: timestamp,
    authCode: code,
    from: 0,
    loginType: 2
  }).then(res => {
    console.log(JSON.stringify(res))
    localStorage.setItem('error', JSON.stringify(res))
    if (res.status === '200') { // 登录成功
      localStorage.setItem('status', '1') // 用户成功登录
      localStorage.setItem('userid', res.data.userId)
      localStorage.setItem('userk', res.data.userKey)
      console.log(store.state.userkey, 1)
      window.location.replace(localStorage.getItem('wxLastUrl')) // 授权成功，跳转回缓存url
    } else if (res.status === '400001001') { // 用户不存在，需要重新授权并注册登录
      if (utils.getQueryString('shareParam') === 'invite') {
        utils.redirectWx('-6')
      } else {
        utils.redirectWx('-2')
      }
    } else if (res.status === '400007001') { // 微信认证失败
      utils.redirectWx('-4')
    } else { // 未知错误，重新授权登录
      utils.redirectWx('-4')
    }
  })
}

// ios微信识别第一链接，jssdk签名要特殊处理
// var originalUrl = utils.isIOS() && utils.isWeixin() ? window.location.href : null

function initVue () {
  store.commit('changeIndexConf', {
    userID: localStorage.getItem('userid'),
    userkey: localStorage.getItem('userk')
  })
  new Vue({
    router,
    store,
    draggable,
    render: h => h(App)
  }).$mount('#app')

  jssdkwx()
}

function jssdkwx () {
  if (utils.isIOS()) {
    utils.jssdkwx(api, Vue.wechat, store, null)
  }
}

// 数字缩写
Vue.filter('earningtype', value => { // 交易明细
  var val
  if (value === 0) {
    val = '奖励'
    value = val
    return value
  } else if (value === 1) {
    val = '收益'
    value = val
    return value
  } else if (value === 2) {
    val = '飞单'
    value = val
    return value
  } else if (value === 3) {
    val = '保险'
    value = val
    return value
  }
})
Vue.filter('analysis', value => { // 交易明细
  var val
  val = value
  value = val.substring(2, val.length - 2)
  return value
})
Vue.filter('fixed', value => {
  if (value === parseInt(value) && value < 10000) {
    return value
  } else if (value >= 10000) {
    var vals = parseFloat(value / 10000)
    value = vals.toFixed(2) + '万'
    return value
  } else if (value < 10000 && value !== parseInt(value)) {
    var val = parseFloat(value).toFixed(2)
    value = val
    return value
  }
})
Vue.filter('money', value => {
  if (value < 10000) {
    return value
  }
  if (value === 10000) {
    value = 1 + '万'
    return value
  }
  if (value > 10000) {
    var val = value / 10000
    if (val === parseInt(val)) {
      value = val + '万'
      return value
    } else {
      var b = val.toFixed(3)
      var c = b.substring(0, b.toString().length - 1)
      value = c + '万'
      return value
    }
  }
})
// 提现记录 提现状态
Vue.filter('recordstatus', function (str) {
  console.log(str)
  switch (str) {
    case 0:
      return '等待提现'
    case 1:
      return '等待放款'
    case 2:
      return '审核驳回'
    case 3:
      return '完成'
    case 4:
      return '放款失败'
  }
})
// 跳骚市场 易手次数
Vue.filter('changehands', function (str) {
  console.log(str)
  switch (str) {
    case 0:
      return '没有易手'
    case 1:
      return '易手1次'
    case 2:
      return '易手2次'
    case 3:
      return '易手3次'
    case 4:
      return '易手4次'
    case 5:
      return '易手5次以上'
  }
})
// 信贷圈子
Vue.filter('timecircle', function (Time) {
  if (Time) {
    var date
    date = Time.substring(0, 19)
    date = date.replace(/-/g, '/')
    var times = new Date(date).getTime()
    var timer = parseFloat(Date.parse(new Date())) - times
    var days = timer / 1000 % 2592000 / 86400 // 天
    var hours = timer / 1000 % 2592000 % 86400 / 3600 // 小时
    var minute = timer / 1000 % 2592000 % 86400 % 3600 / 60 // 分钟
    var str = ''
    if (minute >= 1) {
      str = parseInt(minute) + '分钟前'
    }
    if (hours >= 1) {
      str = parseInt(hours) + '小时前'
    }
    if (days >= 1) {
      return Time
    }
    if (minute < 1) {
      str = '刚刚'
    }
    return str
  }
})
// 个人中心 客户列表
Vue.filter('applystate', function (str) {
  switch (str) {
    case '其他':
      return '全部'
    case 0:
      return '资料填写中'
    case 10:
      return '申请中'
    case 11:
      return '审批中'
    case 12:
      return '待签约'
    case 13:
      return '已拒绝'
    case 14:
      return '签约确认中'
    case 15:
      return '已放弃'
    case 16:
      return '待放款'
    case 17:
      return '放款中'
    case 100:
      return '还款中'
    case 101:
      return '已完成 '
    case 102:
      return '逾期'
  }
})
// 获取时间 只保留日期
Vue.filter('datereserve', function (str) {
  str = str.split(' ')[0]
  return str
})
// 产品详情  过滤最高额度
Vue.filter('maxprice', value => {
  if (value >= 10000) {
    var val = value / 10000
    if (val === parseInt(val)) {
      value = val + '万'
      return value
    } else {
      value = parseFloat(val).toFixed(2) + '万'
      return value
    }
  }
  if (value < 10000) {
    return value
  }
})
